Helper Async Iterator JavaScript: Merevolusi Pemrosesan dan Transformasi Stream

Dalam lanskap pengembangan web dan pemrograman asinkron yang terus berkembang, menangani aliran data secara efisien adalah hal yang terpenting. Baik Anda memproses input pengguna, mengelola respons jaringan, atau mengubah kumpulan data yang besar, kemampuan untuk bekerja dengan aliran data asinkron secara jelas dan mudah dikelola dapat secara signifikan memengaruhi kinerja aplikasi dan produktivitas pengembang. Pengenalan async iterator oleh JavaScript, yang diperkuat dengan proposal Async Iterator Helpers (sekarang menjadi bagian dari ECMAScript 2023), menandai lompatan signifikan dalam hal ini. Artikel ini mengeksplorasi kekuatan helper async iterator, memberikan perspektif global tentang kemampuannya untuk pemrosesan stream dan transformasi data yang canggih.

Dasar-dasar: Memahami Async Iterator

Sebelum mendalami para helper, sangat penting untuk memahami konsep inti dari async iterator. Async iterator adalah objek yang mengimplementasikan metode [Symbol.asyncIterator](). Metode ini mengembalikan objek async iterator, yang pada gilirannya memiliki metode next(). Metode next() mengembalikan sebuah Promise yang me-resolve menjadi objek dengan dua properti: value (item berikutnya dalam urutan) dan done (sebuah boolean yang menunjukkan jika iterasi telah selesai).

Sifat asinkron ini adalah kunci untuk menangani operasi yang mungkin memakan waktu, seperti mengambil data dari API jarak jauh, membaca dari sistem file tanpa memblokir thread utama, atau memproses potongan data dari koneksi WebSocket. Secara tradisional, mengelola urutan asinkron ini dapat melibatkan pola callback yang rumit atau promise chaining. Async iterator, ditambah dengan loop for await...of, menawarkan sintaksis yang jauh lebih mirip sinkron untuk iterasi asinkron.

Kebutuhan akan Helper: Menyederhanakan Operasi Asinkron

Meskipun async iterator menyediakan abstraksi yang kuat, tugas pemrosesan dan transformasi stream yang umum sering kali memerlukan kode boilerplate. Bayangkan perlu memfilter, memetakan, atau mengurangi aliran data asinkron. Tanpa helper khusus, Anda biasanya akan mengimplementasikan operasi ini secara manual, melakukan iterasi melalui async iterator dan membangun urutan baru, yang bisa jadi bertele-tele dan rentan kesalahan.

Proposal Async Iterator Helpers mengatasi hal ini dengan menyediakan serangkaian metode utilitas langsung pada protokol async iterator. Helper ini terinspirasi oleh konsep pemrograman fungsional dan pustaka pemrograman reaktif, membawa pendekatan deklaratif dan dapat disusun (composable) ke aliran data asinkron. Standardisasi ini memudahkan pengembang di seluruh dunia untuk menulis kode asinkron yang konsisten dan dapat dipelihara.

Memperkenalkan Helper Async Iterator

Async Iterator Helpers memperkenalkan beberapa metode kunci yang meningkatkan kemampuan objek async iterable apa pun. Metode-metode ini dapat dirangkai bersama, memungkinkan pipeline data yang kompleks dibangun dengan kejelasan yang luar biasa.

1. .map(): Mengubah Setiap Item

Helper .map() digunakan untuk mengubah setiap item yang dihasilkan oleh async iterator. Ia mengambil fungsi callback yang menerima item saat ini dan harus mengembalikan item yang telah diubah. Async iterator asli tetap tidak berubah; .map() mengembalikan async iterator baru yang menghasilkan nilai-nilai yang telah diubah.

Contoh Kasus Penggunaan (E-commerce Global):

Pertimbangkan sebuah async iterator yang mengambil data produk dari API marketplace internasional. Setiap item mungkin merupakan objek produk yang kompleks. Anda mungkin ingin memetakan objek-objek ini ke format yang lebih sederhana yang hanya berisi nama produk dan harga dalam mata uang tertentu, atau mungkin mengonversi berat ke unit standar seperti kilogram.

            async function* getProductStream(apiEndpoint) {
  // Mensimulasikan pengambilan data produk secara asinkron
  const response = await fetch(apiEndpoint);
  const products = await response.json();
  for (const product of products) {
    yield product;
  }
}

async function transformProductPrices(apiEndpoint, targetCurrency) {
  const productStream = getProductStream(apiEndpoint);

  // Contoh: Mengonversi harga dari USD ke EUR menggunakan kurs
  const exchangeRate = 0.92; // Contoh kurs, biasanya akan diambil dari sumber lain

  const transformedStream = productStream.map(product => {
    const priceInTargetCurrency = (product.priceUSD * exchangeRate).toFixed(2);
    return {
      name: product.name,
      price: `${priceInTargetCurrency} EUR`
    };
  });

  for await (const transformedProduct of transformedStream) {
    console.log(`Transformed: ${transformedProduct.name} - ${transformedProduct.price}`);
  }
}

// Asumsikan respons API tiruan untuk produk
// transformProductPrices('https://api.globalmarketplace.com/products', 'EUR');

            

              
                Copy
              
            
          

Poin Kunci: .map() memungkinkan transformasi satu-ke-satu dari aliran data asinkron, memungkinkan pembentukan dan pengayaan data yang fleksibel.

2. .filter(): Memilih Item yang Relevan

Helper .filter() memungkinkan Anda membuat async iterator baru yang hanya menghasilkan item yang memenuhi kondisi tertentu. Ia mengambil fungsi callback yang menerima sebuah item dan harus mengembalikan true untuk menyimpan item tersebut atau false untuk membuangnya.

Contoh Kasus Penggunaan (Feed Berita Internasional):

Bayangkan memproses aliran asinkron artikel berita dari berbagai sumber global. Anda mungkin ingin menyaring artikel yang tidak menyebutkan negara atau wilayah tertentu yang diminati, atau mungkin hanya menyertakan artikel yang diterbitkan setelah tanggal tertentu.

            async function* getNewsFeed(sourceUrls) {
  for (const url of sourceUrls) {
    // Mensimulasikan pengambilan berita dari sumber jarak jauh
    const response = await fetch(url);
    const articles = await response.json();
    for (const article of articles) {
      yield article;
    }
  }
}

async function filterArticlesByCountry(sourceUrls, targetCountry) {
  const newsStream = getNewsFeed(sourceUrls);

  const filteredStream = newsStream.filter(article => {
    // Asumsikan setiap artikel memiliki properti array 'countries'
    return article.countries && article.countries.includes(targetCountry);
  });

  console.log(`
--- Artikel terkait ${targetCountry} ---`);
  for await (const article of filteredStream) {
    console.log(`- ${article.title} (Sumber: ${article.source})`);
  }
}

// const newsSources = ['https://api.globalnews.com/tech', 'https://api.worldaffairs.org/politics'];
// filterArticlesByCountry(newsSources, 'Japan');

            

              
                Copy
              
            
          

Poin Kunci: .filter() menyediakan cara deklaratif untuk memilih titik data spesifik dari aliran asinkron, yang krusial untuk pemrosesan data terfokus.

3. .take(): Membatasi Panjang Stream

Helper .take() memungkinkan Anda membatasi jumlah item yang dihasilkan oleh async iterator. Ini sangat berguna ketika Anda hanya memerlukan N item pertama dari stream yang berpotensi tak terbatas atau sangat besar.

Contoh Kasus Penggunaan (Log Aktivitas Pengguna):

Saat menganalisis aktivitas pengguna, Anda mungkin hanya perlu memproses 100 event pertama dalam satu sesi, atau mungkin 10 upaya login pertama dari wilayah tertentu.

            async function* getUserActivityStream(userId) {
  // Mensimulasikan pembuatan event aktivitas pengguna
  let eventCount = 0;
  while (eventCount < 500) { // Mensimulasikan stream yang besar
    await new Promise(resolve => setTimeout(resolve, 10)); // Mensimulasikan penundaan asinkron
    yield { event: 'click', timestamp: Date.now(), count: eventCount };
    eventCount++;
  }
}

async function processFirstTenEvents(userId) {
  const activityStream = getUserActivityStream(userId);

  const limitedStream = activityStream.take(10);

  console.log(`
--- Memproses 10 event pengguna pertama ---`);
  let processedCount = 0;
  for await (const event of limitedStream) {
    console.log(`Event ke-${processedCount + 1} diproses: ${event.event} pada ${event.timestamp}`);
    processedCount++;
  }
  console.log(`Total event yang diproses: ${processedCount}`);
}

// processFirstTenEvents('user123');

            

              
                Copy
              
            
          

Poin Kunci: .take() sangat penting untuk mengelola konsumsi sumber daya dan berfokus pada titik data awal dalam urutan asinkron yang berpotensi besar.

4. .drop(): Melewatkan Item Awal

Sebaliknya, .drop() memungkinkan Anda melewatkan sejumlah item tertentu dari awal async iterator. Ini berguna untuk melewati pengaturan awal atau metadata sebelum mencapai data aktual yang ingin Anda proses.

Contoh Kasus Penggunaan (Ticker Data Keuangan):

Saat berlangganan aliran data keuangan real-time, pesan-pesan awal mungkin berupa konfirmasi koneksi atau metadata. Anda mungkin ingin melewatkan ini dan mulai memproses hanya ketika pembaruan harga aktual dimulai.

            async function* getFinancialTickerStream(symbol) {
  // Mensimulasikan jabat tangan/metadata awal
  yield { type: 'connection_ack', timestamp: Date.now() };
  yield { type: 'metadata', exchange: 'NYSE', timestamp: Date.now() };

  // Mensimulasikan pembaruan harga aktual
  let price = 100;
  for (let i = 0; i < 20; i++) {
    await new Promise(resolve => setTimeout(resolve, 50));
    price += (Math.random() - 0.5) * 2;
    yield { type: 'price_update', symbol: symbol, price: price.toFixed(2), timestamp: Date.now() };
  }
}

async function processTickerUpdates(symbol) {
  const tickerStream = getFinancialTickerStream(symbol);

  const dataStream = tickerStream.drop(2); // Lewati dua pesan non-data pertama

  console.log(`
--- Memproses pembaruan ticker untuk ${symbol} ---`);
  for await (const update of dataStream) {
    if (update.type === 'price_update') {
      console.log(`${update.symbol}: $${update.price} pada ${new Date(update.timestamp).toLocaleTimeString()}`);
    }
  }
}

// processTickerUpdates('AAPL');

            

              
                Copy
              
            
          

Poin Kunci: .drop() membantu membersihkan stream dengan membuang elemen awal yang tidak relevan, memastikan bahwa pemrosesan berfokus pada data inti.

5. .reduce(): Mengagregasi Data Stream

Helper .reduce() adalah alat yang kuat untuk mengagregasi seluruh aliran asinkron menjadi satu nilai tunggal. Ia mengambil fungsi callback (reducer) dan nilai awal opsional. Reducer dipanggil untuk setiap item, mengakumulasi hasil dari waktu ke waktu.

Contoh Kasus Penggunaan (Agregasi Data Cuaca Global):

Bayangkan mengumpulkan pembacaan suhu dari stasiun cuaca di berbagai benua. Anda bisa menggunakan .reduce() untuk menghitung suhu rata-rata dari semua pembacaan dalam stream tersebut.

            async function* getWeatherReadings(region) {
  // Mensimulasikan pengambilan pembacaan suhu secara asinkron untuk suatu wilayah
  const readings = [
    { region: 'Eropa', temp: 15 },
    { region: 'Asia', temp: 25 },
    { region: 'Amerika Utara', temp: 18 },
    { region: 'Eropa', temp: 16 },
    { region: 'Afrika', temp: 30 }
  ];
  for (const reading of readings) {
    if (reading.region === region) {
      await new Promise(resolve => setTimeout(resolve, 20));
      yield reading;
    }
  }
}

async function calculateAverageTemperature(regions) {
  let allReadings = [];
  for (const region of regions) {
    const regionReadings = getWeatherReadings(region);
    // Kumpulkan pembacaan dari setiap stream wilayah
    for await (const reading of regionReadings) {
      allReadings.push(reading);
    }
  }

  // Gunakan reduce untuk menghitung suhu rata-rata di semua pembacaan yang dikumpulkan
  const totalTemperature = allReadings.reduce((sum, reading) => sum + reading.temp, 0);
  const averageTemperature = allReadings.length > 0 ? totalTemperature / allReadings.length : 0;

  console.log(`
--- Suhu rata-rata di ${regions.join(', ')}: ${averageTemperature.toFixed(1)}°C ---`);
}

// calculateAverageTemperature(['Eropa', 'Asia', 'Amerika Utara']);

            

              
                Copy
              
            
          

Poin Kunci: .reduce() mengubah aliran data menjadi satu hasil kumulatif tunggal, yang penting untuk agregasi dan ringkasan.

6. .toArray(): Mengkonsumsi Seluruh Stream ke dalam Array

Meskipun tidak sepenuhnya merupakan helper transformasi seperti .map() atau .filter(), .toArray() adalah utilitas krusial untuk mengkonsumsi seluruh async iterator dan mengumpulkan semua nilai yang dihasilkannya ke dalam array JavaScript standar. Ini berguna ketika Anda perlu melakukan operasi spesifik array pada data setelah data tersebut sepenuhnya di-stream.

Contoh Kasus Penggunaan (Memproses Data Batch):

Jika Anda mengambil daftar catatan pengguna dari API berpaginasi, Anda mungkin pertama-tama menggunakan .toArray() untuk mengumpulkan semua catatan dari semua halaman sebelum melakukan operasi massal, seperti membuat laporan atau memperbarui entri basis data.

            async function* getUserBatch(page) {
  // Mensimulasikan pengambilan batch pengguna dari API berpaginasi
  const allUsers = [
    { id: 1, name: 'Alice', country: 'USA' },
    { id: 2, name: 'Bob', country: 'Kanada' },
    { id: 3, name: 'Charlie', country: 'UK' },
    { id: 4, name: 'David', country: 'Australia' }
  ];
  const startIndex = page * 2;
  const endIndex = startIndex + 2;
  for (let i = startIndex; i < endIndex && i < allUsers.length; i++) {
    await new Promise(resolve => setTimeout(resolve, 30));
    yield allUsers[i];
  }
}

async function getAllUsersFromPages() {
  let currentPage = 0;
  let hasMorePages = true;
  let allUsersArray = [];

  while (hasMorePages) {
    const userStreamForPage = getUserBatch(currentPage);
    const usersFromPage = await userStreamForPage.toArray(); // Kumpulkan semua dari halaman saat ini

    if (usersFromPage.length === 0) {
      hasMorePages = false;
    } else {
      allUsersArray = allUsersArray.concat(usersFromPage);
      currentPage++;
    }
  }

  console.log(`
--- Semua pengguna dikumpulkan dari paginasi ---`);
  console.log(`Total pengguna diambil: ${allUsersArray.length}`);
  allUsersArray.forEach(user => console.log(`- ${user.name} (${user.country})`));
}

// getAllUsersFromPages();

            

              
                Copy
              
            
          

Poin Kunci: .toArray() sangat diperlukan ketika Anda perlu bekerja dengan dataset lengkap setelah pengambilan asinkron, memungkinkan pasca-pemrosesan dengan metode array yang sudah dikenal.

7. .concat(): Menggabungkan Beberapa Stream

Helper .concat() memungkinkan Anda untuk menggabungkan beberapa async iterator menjadi satu async iterator sekuensial tunggal. Ia melakukan iterasi melalui iterator pertama sampai selesai, kemudian beralih ke yang kedua, dan seterusnya.

Contoh Kasus Penggunaan (Menggabungkan Sumber Data):

Misalkan Anda memiliki API atau sumber data yang berbeda yang menyediakan jenis informasi serupa (misalnya, data pelanggan dari basis data regional yang berbeda). .concat() memungkinkan Anda untuk menggabungkan stream-stream ini secara mulus menjadi satu dataset terpadu untuk diproses.

            async function* streamSourceA() {
  yield { id: 1, name: 'A1', type: 'sourceA' };
  yield { id: 2, name: 'A2', type: 'sourceA' };
}

async function* streamSourceB() {
  yield { id: 3, name: 'B1', type: 'sourceB' };
  await new Promise(resolve => setTimeout(resolve, 50));
  yield { id: 4, name: 'B2', type: 'sourceB' };
}

async function* streamSourceC() {
  yield { id: 5, name: 'C1', type: 'sourceC' };
}

async function processConcatenatedStreams() {
  const streamA = streamSourceA();
  const streamB = streamSourceB();
  const streamC = streamSourceC();

  // Gabungkan stream A, B, dan C
  const combinedStream = streamA.concat(streamB, streamC);

  console.log(`
--- Memproses stream yang digabungkan ---`);
  for await (const item of combinedStream) {
    console.log(`Diterima dari ${item.type}: ${item.name} (ID: ${item.id})`);
  }
}

// processConcatenatedStreams();

            

              
                Copy
              
            
          

Poin Kunci: .concat() menyederhanakan penyatuan data dari sumber asinkron yang berbeda menjadi satu stream tunggal yang mudah dikelola.

8. .join(): Membuat String dari Elemen Stream

Mirip dengan Array.prototype.join(), helper .join() untuk async iterator menggabungkan semua item yang dihasilkan menjadi satu string tunggal, menggunakan pemisah yang ditentukan. Ini sangat berguna untuk menghasilkan laporan atau file log.

Contoh Kasus Penggunaan (Pembuatan File Log):

Saat membuat output log yang diformat dari aliran asinkron entri log, .join() dapat digunakan untuk menggabungkan entri-entri ini menjadi satu string tunggal, yang kemudian dapat ditulis ke file atau ditampilkan.

            async function* getLogEntries() {
  await new Promise(resolve => setTimeout(resolve, 10));
  yield "[INFO] Pengguna masuk.";
  await new Promise(resolve => setTimeout(resolve, 10));
  yield "[WARN] Ruang disk menipis.";
  await new Promise(resolve => setTimeout(resolve, 10));
  yield "[ERROR] Koneksi basis data gagal.";
}

async function generateLogString() {
  const logStream = getLogEntries();

  // Gabungkan entri log dengan karakter baris baru
  const logFileContent = await logStream.join('\n');

  console.log(`
--- Konten Log yang Dihasilkan ---`);
  console.log(logFileContent);
}

// generateLogString();

            

              
                Copy
              
            
          

Poin Kunci: .join() secara efisien mengubah urutan asinkron menjadi output string yang diformat, menyederhanakan pembuatan artefak data tekstual.

Merangkai untuk Pipeline yang Kuat

Kekuatan sebenarnya dari para helper ini terletak pada kemampuannya untuk disusun melalui perangkaian (chaining). Anda dapat membuat pipeline pemrosesan data yang rumit dengan menghubungkan beberapa helper bersama-sama. Gaya deklaratif ini membuat operasi asinkron yang kompleks jauh lebih mudah dibaca dan dipelihara daripada pendekatan imperatif tradisional.

Contoh: Mengambil, Memfilter, dan Mengubah Data Pengguna

Mari kita bayangkan mengambil data pengguna dari API global, memfilter pengguna di wilayah tertentu, dan kemudian mengubah nama dan email mereka menjadi format tertentu.

            async function* fetchGlobalUserData() {
  // Mensimulasikan pengambilan data dari berbagai sumber, menghasilkan objek pengguna
  const users = [
    { id: 1, name: 'Alice Smith', country: 'USA', email: 'alice.s@example.com' },
    { id: 2, name: 'Bob Johnson', country: 'Kanada', email: 'bob.j@example.com' },
    { id: 3, name: 'Chiyo Tanaka', country: 'Jepang', email: 'chiyo.t@example.com' },
    { id: 4, name: 'David Lee', country: 'Korea Selatan', email: 'david.l@example.com' },
    { id: 5, name: 'Eva Müller', country: 'Jerman', email: 'eva.m@example.com' },
    { id: 6, name: 'Kenji Sato', country: 'Jepang', email: 'kenji.s@example.com' }
  ];
  for (const user of users) {
    await new Promise(resolve => setTimeout(resolve, 15));
    yield user;
  }
}

async function processFilteredUsers(targetCountries) {
  const userDataStream = fetchGlobalUserData();

  const processedStream = userDataStream
    .filter(user => targetCountries.includes(user.country))
    .map(user => ({
      fullName: user.name.toUpperCase(),
      contactEmail: user.email.toLowerCase()
    }))
    .take(3); // Ambil hingga 3 pengguna yang telah diubah dari daftar yang difilter

  console.log(`
--- Memproses hingga 3 pengguna dari: ${targetCountries.join(', ')} ---`);
  for await (const processedUser of processedStream) {
    console.log(`Nama: ${processedUser.fullName}, Email: ${processedUser.contactEmail}`);
  }
}

// processFilteredUsers(['Jepang', 'Jerman']);

            

              
                Copy
              
            
          

Contoh ini menunjukkan bagaimana .filter(), .map(), dan .take() dapat dirangkai dengan elegan untuk melakukan operasi data asinkron multi-langkah yang kompleks.

Pertimbangan Global dan Praktik Terbaik

Saat bekerja dengan iterator asinkron dan helpernya dalam konteks global, beberapa faktor menjadi penting:

• Internasionalisasi (i18n) & Lokalisasi (l10n): Saat mengubah data, terutama string atau nilai numerik (seperti harga atau tanggal), pastikan logika pemetaan dan pemfilteran Anda mengakomodasi lokal yang berbeda. Misalnya, format mata uang, penguraian tanggal, dan pemisah angka sangat bervariasi antar negara. Fungsi transformasi Anda harus dirancang dengan mempertimbangkan i18n, berpotensi menggunakan pustaka untuk format internasional yang kuat.
• Penanganan Kesalahan: Operasi asinkron rentan terhadap kesalahan (masalah jaringan, data tidak valid). Setiap metode helper harus digunakan dalam strategi penanganan kesalahan yang kuat. Menggunakan blok try...catch di sekitar loop for await...of sangat penting. Beberapa helper mungkin juga menawarkan cara untuk menangani kesalahan dalam fungsi callback mereka (misalnya, mengembalikan nilai default atau objek kesalahan tertentu).
• Kinerja dan Manajemen Sumber Daya: Meskipun helper menyederhanakan kode, waspadai konsumsi sumber daya. Operasi seperti .toArray() dapat memuat seluruh dataset besar ke dalam memori, yang mungkin menjadi masalah untuk stream yang sangat besar. Pertimbangkan untuk menggunakan transformasi perantara dan menghindari array perantara yang tidak perlu. Untuk stream tak terbatas, helper seperti .take() sangat penting untuk mencegah kehabisan sumber daya.
• Observabilitas: Untuk pipeline yang kompleks, melacak aliran data dan mengidentifikasi bottleneck bisa menjadi tantangan. Pertimbangkan untuk menambahkan logging di dalam callback .map() atau .filter() Anda (selama pengembangan) untuk memahami data apa yang sedang diproses di setiap tahap.
• Kompatibilitas: Meskipun Async Iterator Helpers adalah bagian dari ECMAScript 2023, pastikan lingkungan target Anda (browser, versi Node.js) mendukung fitur-fitur ini. Polyfill mungkin diperlukan untuk lingkungan yang lebih lama.
• Komposisi Fungsional: Rangkul paradigma pemrograman fungsional. Helper ini mendorong penyusunan fungsi-fungsi murni yang lebih kecil untuk membangun perilaku yang kompleks. Hal ini membuat kode lebih mudah diuji, dapat digunakan kembali, dan lebih mudah dipahami di berbagai budaya dan latar belakang pemrograman.

Masa Depan Pemrosesan Stream Asinkron di JavaScript

Async Iterator Helpers merupakan langkah signifikan menuju pola pemrograman asinkron yang lebih terstandardisasi dan kuat di JavaScript. Mereka menjembatani kesenjangan antara pendekatan imperatif dan fungsional, menawarkan cara deklaratif dan sangat mudah dibaca untuk mengelola aliran data asinkron.

Seiring para pengembang secara global mengadopsi pola-pola ini, kita dapat berharap untuk melihat lebih banyak pustaka dan kerangka kerja canggih yang dibangun di atas fondasi ini. Kemampuan untuk menyusun transformasi data yang kompleks dengan kejelasan seperti itu sangat berharga untuk membangun aplikasi yang skalabel, efisien, dan dapat dipelihara yang melayani basis pengguna internasional yang beragam.

Kesimpulan

Helper Async Iterator JavaScript adalah pengubah permainan bagi siapa saja yang bekerja dengan aliran data asinkron. Dari transformasi sederhana dengan .map() dan .filter() hingga agregasi kompleks dengan .reduce() dan penggabungan stream dengan .concat(), alat-alat ini memberdayakan pengembang untuk menulis kode yang lebih bersih, lebih efisien, dan lebih kuat.

Dengan memahami dan memanfaatkan para helper ini, pengembang di seluruh dunia dapat meningkatkan kemampuan mereka untuk memproses dan mengubah data asinkron, yang mengarah pada kinerja aplikasi yang lebih baik dan pengalaman pengembangan yang lebih produktif. Rangkullah tambahan-tambahan kuat ini pada kemampuan asinkron JavaScript dan buka tingkat efisiensi baru dalam upaya pemrosesan stream Anda.